package com.jmb.api.web.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jmb.api.common.exception.WebApiException;
import com.jmb.api.common.result.ResultCodeEnum;
import com.jmb.api.entity.InterfaceCase;
import com.jmb.api.entity.InterfacePreCase;
import com.jmb.api.web.service.InterfacePreCaseService;
import com.jmb.api.web.mapper.InterfacePreCaseMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
* @author 金梦博
* @description 针对表【t_interface_pre_case】的数据库操作Service实现
* @createDate 2025-09-25 17:19:28
*/
@Slf4j
@Service
public class InterfacePreCaseServiceImpl extends ServiceImpl<InterfacePreCaseMapper, InterfacePreCase>
    implements InterfacePreCaseService{

    @Autowired
    private InterfacePreCaseMapper interfacePreCaseMapper;

    /**
     * 保存前置用例
     * @param interfacePreCase 前置用例
     */
    @Override
    public void saveOrUpdateInterfacePreCase(InterfacePreCase interfacePreCase) {
        // 判断是更新还是新增
        boolean isUpdate = interfacePreCase.getId() != null;

        InterfacePreCase preCase = interfacePreCaseMapper.selectById(interfacePreCase.getPreCaseId());
        if (preCase == null){
            log.error("保存前置用例，前置用例编号不存在");
            throw new WebApiException(ResultCodeEnum.PRE_CASE_NOT_EXIST);
        }
        // 前置用例不能为自身
        if (interfacePreCase.getPreCaseId().equals(interfacePreCase.getParentCaseId())){
            log.error("保存前置用例，前置用例编号不能为自身");
            throw new WebApiException(ResultCodeEnum.PRE_CASE_NOT_SELF);
        }
        // 查询语句
        LambdaQueryWrapper<InterfacePreCase> preCaseWrapper = new LambdaQueryWrapper<>();
        if (isUpdate){
            preCaseWrapper.ne(InterfacePreCase::getId, interfacePreCase.getId());

        }
       super.saveOrUpdate(interfacePreCase);

    }

    /**
     * 根据父级用例编号查询所有前置用例编号
     * @param id 父级用例编号
     * @return 前置用例编号
     */
    @Override
    public List<Long> findInterfacePreIdByParentId(Long id) {
        return interfacePreCaseMapper.selectInterfacePreIdByParentId(id);
    }

    /**
     * 查询所有用例的前置用例
     * @param CaseId 父用例ID
     * @return 前置用例集合 List<InterfacePreCase>
     */

    @Override
    public List<InterfacePreCase> findInterfacePreCaseByCaseId(Long CaseId) {
        LambdaQueryWrapper<InterfacePreCase> preCaseLambdaQueryWrapper = new LambdaQueryWrapper<>();
        preCaseLambdaQueryWrapper.eq(InterfacePreCase::getParentCaseId, CaseId)
                .eq(InterfacePreCase::getStatus, 0)
                .orderByAsc(InterfacePreCase::getOrder);
        return interfacePreCaseMapper.selectList(preCaseLambdaQueryWrapper);
    }

    /**
     * 查询用例的前置用例编号集合
     * @param parentCaseId 用例编号
     * @return 前置用例集合
     */
    @Override
    public List<Long> findInterfacePreCaseIdByParentId(Long parentCaseId) {
        return interfacePreCaseMapper.selectInterfacePreCaseId(parentCaseId);
    }

    /**
     * 递归获取所有的前置用例（含前置用例包含的前置用例）集合
     * @param returnResult 用来接收返回数据的集合
     * @param parentCaseId 父用例编号
     * @return 取所有的前置用例（含前置用例包含的前置用例）集合
     */
    @Override
    public List<Long> recursionPreCase(List<Long> returnResult, Long parentCaseId) {
        List<Long> list = this.findInterfacePreCaseIdByParentId(parentCaseId);
        returnResult.addAll(list);
        for (Long id : list){
            List<Long> recursionPreCases = recursionPreCase(new ArrayList<>(), id);
            returnResult.addAll(recursionPreCases);

        }
        return returnResult;
    }

    @Override
    public List<InterfacePreCase> findInterfacePreCaseByParentId(Long parentCaseId) {
        LambdaQueryWrapper<InterfacePreCase> preCaseLambdaQueryWrapper = new LambdaQueryWrapper<>();
        preCaseLambdaQueryWrapper.eq(InterfacePreCase::getParentCaseId, parentCaseId)
                .eq(InterfacePreCase::getStatus, 0)
                .orderByAsc(InterfacePreCase::getOrder);
        return interfacePreCaseMapper.selectList(preCaseLambdaQueryWrapper);

    }


}




